const userService = require('../services/user.service');
const cacheService = require('../services/cache.service');
const db = require('../models');
const { success, error } = require('../utils/response');

/**
 * 用户控制器
 * 处理用户相关的API请求
 */
class UserController {
  /**
   * 获取用户列表
   * @param {Object} req - 请求对象
   * @param {Object} res - 响应对象
   * @param {Function} next - 下一个中间件
   */
  async getAllUsers(req, res, next) {
    try {
      const { page = 1, limit = 10, search } = req.query;
      
      // 构建缓存键
      const cacheKey = `users:list:${page}:${limit}:${search || 'all'}`;
      
      // 尝试从缓存获取，如果没有则从数据库获取并缓存
      const users = await cacheService.getOrSet(cacheKey, async () => {
        const options = {};
        
        // 添加搜索条件
        if (search) {
          options.where = {
            [db.Sequelize.Op.or]: [
              { username: { [db.Sequelize.Op.like]: `%${search}%` } },
              { email: { [db.Sequelize.Op.like]: `%${search}%` } }
            ]
          };
        }
        
        // 添加分页
        options.offset = (page - 1) * limit;
        options.limit = parseInt(limit);
        
        return await userService.findAll(options);
      }, 300); // 缓存5分钟
      
      res.json(success(users, '获取用户列表成功'));
    } catch (err) {
      next(err);
    }
  }

  /**
   * 获取单个用户
   * @param {Object} req - 请求对象
   * @param {Object} res - 响应对象
   * @param {Function} next - 下一个中间件
   */
  async getUserById(req, res, next) {
    try {
      const { id } = req.params;
      
      // 构建缓存键
      const cacheKey = `users:${id}`;
      
      // 尝试从缓存获取，如果没有则从数据库获取并缓存
      const user = await cacheService.getOrSet(cacheKey, async () => {
        return await userService.findById(id);
      }, 600); // 缓存10分钟
      
      if (!user) {
        return res.status(404).json(error('用户不存在', 404));
      }
      
      res.json(success(user, '获取用户成功'));
    } catch (err) {
      next(err);
    }
  }

  /**
   * 创建用户
   * @param {Object} req - 请求对象
   * @param {Object} res - 响应对象
   * @param {Function} next - 下一个中间件
   */
  async createUser(req, res, next) {
    try {
      const userData = req.body;
      
      // 验证必填字段
      if (!userData.email) {
        return res.status(400).json(error('email 不能为空', 400));
      }
      
      // 创建用户
      const user = await userService.create(userData);
      
      // 清除用户列表缓存
      await cacheService.delByPattern('users:list:*');
      
      res.status(201).json(success(user, '用户创建成功', 201));
    } catch (err) {
      next(err);
    }
  }

  /**
   * 更新用户
   * @param {Object} req - 请求对象
   * @param {Object} res - 响应对象
   * @param {Function} next - 下一个中间件
   */
  async updateUser(req, res, next) {
    try {
      const { id } = req.params;
      const userData = req.body;
      
      // 检查用户是否存在
      const existingUser = await userService.findById(id);
      
      if (!existingUser) {
        return res.status(404).json(error('用户不存在', 404));
      }
      
      // 更新用户
      await userService.update(id, userData);
      
      // 清除相关缓存
      await cacheService.del(`users:${id}`);
      await cacheService.delByPattern('users:list:*');
      
      // 获取更新后的用户
      const updatedUser = await userService.findById(id);
      
      res.json(success(updatedUser, '用户更新成功'));
    } catch (err) {
      next(err);
    }
  }

  /**
   * 删除用户
   * @param {Object} req - 请求对象
   * @param {Object} res - 响应对象
   * @param {Function} next - 下一个中间件
   */
  async deleteUser(req, res, next) {
    try {
      const { id } = req.params;
      
      // 检查用户是否存在
      const existingUser = await userService.findById(id);
      
      if (!existingUser) {
        return res.status(404).json(error('用户不存在', 404));
      }
      
      // 删除用户
      await userService.delete(id);
      
      // 清除相关缓存
      await cacheService.del(`users:${id}`);
      await cacheService.delByPattern('users:list:*');
      
      res.status(204).end();
    } catch (err) {
      next(err);
    }
  }

  /**
   * 获取当前登录用户信息
   * @param {Object} req - 请求对象
   * @param {Object} res - 响应对象
   * @param {Function} next - 下一个中间件
   */
  async getCurrentUser(req, res, next) {
    try {
      const userId = req.user.id;
      
      // 获取用户信息
      const user = await userService.findById(userId);
      
      if (!user) {
        return res.status(404).json(error('用户不存在', 404));
      }
      
      res.json(success(user, '获取当前用户信息成功'));
    } catch (err) {
      next(err);
    }
  }
}

module.exports = new UserController();